Pour un apprentissage rapide je recommande cette lecture (tout est dans le titre) http://learnxinyminutes.com/docs/julia/
Regardons les possibilités de calcul offert par cet environnement !
On est devant une superbe calculatrice comme dans la console de Matlab/Scilab ou R. On a donc l'utilisation des opérateurs classique +-*/\^ ainsi que toutes les fonctions scientifiques sin, cos exp log (attention ici logarithme népérien)....
voir https://docs.julialang.org/en/v1/manual/mathematical-operations/
A remarquer l'utilisation de la fonction log comme le logarithme naturel (Népérien).
In [1]:
log(100)
Out[1]:
In [2]:
log10(100)
Out[2]:
| Fonctions usuelles |
|---|
| exp, log, log10, abs, sqrt, cbrt, sign |
| Fonctions trigonométriques usuelles |
|---|
| sin, cos, tan, cot, sec, csc, sinh, cosh, tanh, coth, sech, csch, asin, acos, atan |
| acot, asec, acsc, asinh, acosh, atanh, acoth, asech, acsch, sinc, cosc, atan2 |
Il est possible d'utiliser les notations scientifiques 1e2 pour 100, ainsi que quelques nombre prédéfinis pi, e, im ...
In [3]:
1e-2
Out[3]:
In [4]:
2*pi
Out[4]:
In [5]:
im^2
Out[5]:
Certaines fonctions sont possèdent un domaine de définition comme sqrt, log... sur $I\!\!R$ extensible aux nombres complexes :
In [6]:
sqrt(-1)
In [7]:
sqrt(complex(-1))
Out[7]:
L'ensemble des fonctions scientifique est étendu au calcul complexe !
In [8]:
sin(1+im)
Out[8]:
| Fonctions d'arrondi |
|---|
| round, floor, ceil, trunc |
JULIA possède une algèbre étendue avec la possibilité de divisé par 0
In [9]:
1/0
Out[9]:
In [10]:
1/Inf
Out[10]:
In [11]:
Inf+1
Out[11]:
In [12]:
Inf/Inf
Out[12]:
In [13]:
Inf-Inf
Out[13]:
In [14]:
0*Inf
Out[14]:
In [15]:
NaN+1
Out[15]:
Inf et NaN représentant l'infini et Not A Number. Toutes les formes indéterminées donnant NaN et toute combinaison avec NaN renvoie également NaN.
L'utilisation de variable est très intuitive sans déclaration préalable de type (entier, réel, imaginaire, fraction rationnelle...). Le nom de la variable doit commencer par une lettre entre a-z ou A-Z mais aussi par un underscore ('_') ou encore un caractère Unicode (voir dernier exemple pour comprendre)
In [16]:
a=1
Out[16]:
In [17]:
typeof(a)
Out[17]:
In [18]:
b=sqrt(2)
Out[18]:
In [19]:
typeof(b)
Out[19]:
In [20]:
c=9//12
Out[20]:
In [21]:
typeof(c)
Out[21]:
In [22]:
c=a+b;
typeof(c)
Out[22]:
On voit dans ce qui précède que les variables sont typées, mais un mécanisme automatique de changement de type (comme Int64 $ \rightarrow$ Float64) permet la somme d'un entier et d'un réel. On peut demander à JULIA d'identifier un entier comme un réel (Float) avec l'ajout d'un . exemple a=1..
Une particularité est de ne pas avoir la possibilité de supprimer une variable ! Il est juste possible de récupérer l'espace mémoire en faisant a=[].
In [23]:
a=[]
Out[23]:
Toujours dans la rubrique particularité on verra que les fonctions sont aussi des variables, il sera donc possible de les passer en argument, de les affecter etc...
In [24]:
ρ¹=1
Out[24]:
L'utilisation de caractères spétiaux comme les lettres grecques se font par utilisation d'une syntaxe de type LaTex. Dans la Plupart des éditeurs il faut commencer par \rho puis la touche TAB fait afficher le charactère
Julia impose quelques restriction de nom de variable, de plus les conventions suivantes sont d'usage :
Julia n'est pas à proprement parler un "langage objet" néanmoins c'est ce que l'on peut appeler un "langage typé". En effet ce langage possède un certain nombre de types prédéfinis et permet d'en ajouter à volonter. Les nouveaux types faisant office de structure tel un objet (C++/Java...) permettant la surcharge des opérateurs standarts *, /, + ....
On a vu précédemment que JULIA est assez flexible sur l'utilisation et affectation des variable et est capable de rendre compatible l'addition d'entier, réel (float)...
De manière naturel on trouve les types :
int8, uint8, int16, uint16,int32, uint32, int64, uint64,int128, uint128.float16 (simple précision i.e 8 chiffres significatifs), float32 (double précision, 16 chiffres significatifs), float64 (32 chiffres significatifs)complex32, complex64, complex128.
In [25]:
a=1000000000000; typeof(a)
Out[25]:
In [26]:
a=10000000000000000000; typeof(a)
Out[26]:
In [27]:
b=10;
println(typeof(b))
b=Int32(b)
println(typeof(b))
In [28]:
convert(Float64,b)
Float64(b)
Out[28]:
In [29]:
c=1.0;
println(typeof(c))
Il est possible de forcer le type d'une variable à l'aide des commandes Int8(), Int16()...Float32()...
Remarque : Opétations type unaire sur une variable
| opération | += | -= | *= | /= | \= | |------|------|------|------|------|------|
In [30]:
a=1
a+=1
Out[30]:
In [31]:
a*=3
Out[31]:
In [32]:
a = 1>0 ;println(a) ;typeof(a)
Out[32]:
Avec les opérateurs de conjonctions
| et | ou | not |
|---|---|---|
| & | | | ! |
In [33]:
!((a&true) & (a|false))
Out[33]:
In [34]:
2>1 & 0>-1
Out[34]:
In [35]:
z='a'
Out[35]:
In [36]:
z=z+1 # en ajoutant 1 on passe aux charactère suivant dans la table
Out[36]:
La chaine de caractère est délimitée par "" et définit unt type ASCIIString ou UTF8String
In [37]:
a="Une chaine de caractère \n" # \n est le retour à la ligne
Out[37]:
In [38]:
typeof(a)
Out[38]:
La concaténation de chaîne se fait par l'utilisation de * (multiplication)
In [39]:
b= a * "puis une autre..."
Out[39]:
In [40]:
println(b) # \n renvoie à la ligne
On peut extraire ou affecter une partie de cette chaîne considérée comme un tableau
In [41]:
a[1:10]
Out[41]:
In [42]:
a[1] # le résultat est de type Char
Out[42]:
In [43]:
a[1:1]
Out[43]:
In [44]:
println(string(typeof(a[1]))*"\n")
println(string(typeof(a[1:1])))
L'usage de $ permet comme en php de convertir et d'inclure une variable dans une chaîne de caractère (interpolation)
In [45]:
m=11;
a="le mois de novembre est le $m ième mois "
Out[45]:
In [46]:
b="racine de 2 : $(sqrt(2))"
Out[46]:
Pour encore plus de possibilités avec les chaînes de caractère : https://docs.julialang.org/en/v1/manual/strings/#man-strings-1